﻿namespace UnityEditorInternal
{
    using NUnit.Framework;
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Runtime.CompilerServices;
    using System.Runtime.InteropServices;
    using UnityEditor;
    using UnityEditor.Scripting;
    using UnityEngine;

    public sealed class InternalEditorUtility
    {
        [CompilerGenerated]
        private static Dictionary<string, int> <>f__switch$map0;

        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern int AddScriptComponentUnchecked(GameObject gameObject, MonoScript script);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void BumpMapSettingsFixingWindowReportResult(int result);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern bool BumpMapTextureNeedsFixing(Material material);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern string CalculateHashForObjectsAndDependencies(UnityEngine.Object[] objects);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern Bounds CalculateSelectionBounds(bool usePivotOnlyForParticles);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern bool CalculateShouldEnableLights();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern bool CanConnectToCacheServer();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void ExecuteCommandOnKeyWindow(string commandName);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void FixNormalmapTexture(Material material);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern string GetAuthToken();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern string[] GetAvailableDiffTools();
        public static Rect GetBoundsOfDesktopAtPoint(Vector2 pos)
        {
            return INTERNAL_CALL_GetBoundsOfDesktopAtPoint(ref pos);
        }

        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern Resolution GetDesktopResolution();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern string GetEditorAssemblyPath();
        public static string[] GetEditorSettingsList(string prefix, int count)
        {
            ArrayList list = new ArrayList();
            for (int i = 1; i <= count; i++)
            {
                string str = EditorPrefs.GetString(prefix + i, "defaultValue");
                if (str == "defaultValue")
                {
                    break;
                }
                list.Add(str);
            }
            return (list.ToArray(typeof(string)) as string[]);
        }

        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern string GetEngineAssemblyPath();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern string GetExternalScriptEditor();
        private static bool GetFirstAndLastSelected(List<int> allInstanceIDs, List<int> selectedInstanceIDs, out int firstIndex, out int lastIndex)
        {
            firstIndex = -1;
            lastIndex = -1;
            for (int i = 0; i < allInstanceIDs.Count; i++)
            {
                if (selectedInstanceIDs.Contains(allInstanceIDs[i]))
                {
                    if (firstIndex == -1)
                    {
                        firstIndex = i;
                    }
                    lastIndex = i;
                }
            }
            return ((firstIndex != -1) && (lastIndex != -1));
        }

        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern string GetFullUnityVersion();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern int GetGameObjectInstanceIDFromComponent(int instanceID);
        public static Texture2D GetIconForFile(string fileName)
        {
            int num = fileName.LastIndexOf('.');
            string key = (num != -1) ? fileName.Substring(num + 1).ToLower() : string.Empty;
            if (key != null)
            {
                int num2;
                if (<>f__switch$map0 == null)
                {
                    Dictionary<string, int> dictionary = new Dictionary<string, int>(0x75);
                    dictionary.Add("boo", 0);
                    dictionary.Add("cginc", 1);
                    dictionary.Add("cs", 2);
                    dictionary.Add("guiskin", 3);
                    dictionary.Add("js", 4);
                    dictionary.Add("mat", 5);
                    dictionary.Add("prefab", 6);
                    dictionary.Add("shader", 7);
                    dictionary.Add("txt", 8);
                    dictionary.Add("unity", 9);
                    dictionary.Add("asset", 10);
                    dictionary.Add("prefs", 10);
                    dictionary.Add("anim", 11);
                    dictionary.Add("ttf", 12);
                    dictionary.Add("otf", 12);
                    dictionary.Add("fon", 12);
                    dictionary.Add("fnt", 12);
                    dictionary.Add("aac", 13);
                    dictionary.Add("aif", 13);
                    dictionary.Add("aiff", 13);
                    dictionary.Add("au", 13);
                    dictionary.Add("mid", 13);
                    dictionary.Add("midi", 13);
                    dictionary.Add("mp3", 13);
                    dictionary.Add("mpa", 13);
                    dictionary.Add("ra", 13);
                    dictionary.Add("ram", 13);
                    dictionary.Add("wma", 13);
                    dictionary.Add("wav", 13);
                    dictionary.Add("wave", 13);
                    dictionary.Add("ogg", 13);
                    dictionary.Add("ai", 14);
                    dictionary.Add("apng", 14);
                    dictionary.Add("png", 14);
                    dictionary.Add("bmp", 14);
                    dictionary.Add("cdr", 14);
                    dictionary.Add("dib", 14);
                    dictionary.Add("eps", 14);
                    dictionary.Add("exif", 14);
                    dictionary.Add("gif", 14);
                    dictionary.Add("ico", 14);
                    dictionary.Add("icon", 14);
                    dictionary.Add("j", 14);
                    dictionary.Add("j2c", 14);
                    dictionary.Add("j2k", 14);
                    dictionary.Add("jas", 14);
                    dictionary.Add("jiff", 14);
                    dictionary.Add("jng", 14);
                    dictionary.Add("jp2", 14);
                    dictionary.Add("jpc", 14);
                    dictionary.Add("jpe", 14);
                    dictionary.Add("jpeg", 14);
                    dictionary.Add("jpf", 14);
                    dictionary.Add("jpg", 14);
                    dictionary.Add("jpw", 14);
                    dictionary.Add("jpx", 14);
                    dictionary.Add("jtf", 14);
                    dictionary.Add("mac", 14);
                    dictionary.Add("omf", 14);
                    dictionary.Add("qif", 14);
                    dictionary.Add("qti", 14);
                    dictionary.Add("qtif", 14);
                    dictionary.Add("tex", 14);
                    dictionary.Add("tfw", 14);
                    dictionary.Add("tga", 14);
                    dictionary.Add("tif", 14);
                    dictionary.Add("tiff", 14);
                    dictionary.Add("wmf", 14);
                    dictionary.Add("psd", 14);
                    dictionary.Add("exr", 14);
                    dictionary.Add("3df", 15);
                    dictionary.Add("3dm", 15);
                    dictionary.Add("3dmf", 15);
                    dictionary.Add("3ds", 15);
                    dictionary.Add("3dv", 15);
                    dictionary.Add("3dx", 15);
                    dictionary.Add("blend", 15);
                    dictionary.Add("c4d", 15);
                    dictionary.Add("lwo", 15);
                    dictionary.Add("lws", 15);
                    dictionary.Add("ma", 15);
                    dictionary.Add("max", 15);
                    dictionary.Add("mb", 15);
                    dictionary.Add("mesh", 15);
                    dictionary.Add("obj", 15);
                    dictionary.Add("vrl", 15);
                    dictionary.Add("wrl", 15);
                    dictionary.Add("wrz", 15);
                    dictionary.Add("fbx", 15);
                    dictionary.Add("asf", 0x10);
                    dictionary.Add("asx", 0x10);
                    dictionary.Add("avi", 0x10);
                    dictionary.Add("dat", 0x10);
                    dictionary.Add("divx", 0x10);
                    dictionary.Add("dvx", 0x10);
                    dictionary.Add("mlv", 0x10);
                    dictionary.Add("m2l", 0x10);
                    dictionary.Add("m2t", 0x10);
                    dictionary.Add("m2ts", 0x10);
                    dictionary.Add("m2v", 0x10);
                    dictionary.Add("m4e", 0x10);
                    dictionary.Add("m4v", 0x10);
                    dictionary.Add("mjp", 0x10);
                    dictionary.Add("mov", 0x10);
                    dictionary.Add("movie", 0x10);
                    dictionary.Add("mp21", 0x10);
                    dictionary.Add("mp4", 0x10);
                    dictionary.Add("mpe", 0x10);
                    dictionary.Add("mpeg", 0x10);
                    dictionary.Add("mpg", 0x10);
                    dictionary.Add("mpv2", 0x10);
                    dictionary.Add("ogm", 0x10);
                    dictionary.Add("qt", 0x10);
                    dictionary.Add("rm", 0x10);
                    dictionary.Add("rmvb", 0x10);
                    dictionary.Add("wmw", 0x10);
                    dictionary.Add("xvid", 0x10);
                    <>f__switch$map0 = dictionary;
                }
                if (<>f__switch$map0.TryGetValue(key, out num2))
                {
                    switch (num2)
                    {
                        case 0:
                            return EditorGUIUtility.FindTexture("boo Script Icon");

                        case 1:
                            return EditorGUIUtility.FindTexture("CGProgram Icon");

                        case 2:
                            return EditorGUIUtility.FindTexture("cs Script Icon");

                        case 3:
                            return EditorGUIUtility.FindTexture("GUISkin Icon");

                        case 4:
                            return EditorGUIUtility.FindTexture("Js Script Icon");

                        case 5:
                            return EditorGUIUtility.FindTexture("Material Icon");

                        case 6:
                            return EditorGUIUtility.FindTexture("PrefabNormal Icon");

                        case 7:
                            return EditorGUIUtility.FindTexture("Shader Icon");

                        case 8:
                            return EditorGUIUtility.FindTexture("TextAsset Icon");

                        case 9:
                            return EditorGUIUtility.FindTexture("SceneAsset Icon");

                        case 10:
                            return EditorGUIUtility.FindTexture("GameManager Icon");

                        case 11:
                            return EditorGUIUtility.FindTexture("Animation Icon");

                        case 12:
                            return EditorGUIUtility.FindTexture("Font Icon");

                        case 13:
                            return EditorGUIUtility.FindTexture("AudioClip Icon");

                        case 14:
                            return EditorGUIUtility.FindTexture("Texture Icon");

                        case 15:
                            return EditorGUIUtility.FindTexture("Mesh Icon");

                        case 0x10:
                            return EditorGUIUtility.FindTexture("MovieTexture Icon");
                    }
                }
            }
            return EditorGUIUtility.FindTexture("DefaultAsset Icon");
        }

        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern bool GetIsInspectorExpanded(UnityEngine.Object obj);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern string GetLayerName(int layer);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern int[] GetLicenseFlags();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern string GetLicenseInfo();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern UnityEngine.Object GetLoadedObjectFromInstanceID(int instanceID);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        internal static extern MonoIsland[] GetMonoIslands();
        public static List<int> GetNewSelection(int clickedInstanceID, List<int> allInstanceIDs, List<int> selectedInstanceIDs, int lastClickedInstanceID, bool keepMultiSelection, bool useShiftAsActionKey, bool allowMultiSelection)
        {
            List<int> list = new List<int>();
            bool flag = Event.current.shift || (EditorGUI.actionKey && useShiftAsActionKey);
            bool flag2 = EditorGUI.actionKey && !useShiftAsActionKey;
            if (!allowMultiSelection)
            {
                flag = flag2 = false;
            }
            if (flag2)
            {
                list.AddRange(selectedInstanceIDs);
                if (list.Contains(clickedInstanceID))
                {
                    list.Remove(clickedInstanceID);
                    return list;
                }
                list.Add(clickedInstanceID);
                return list;
            }
            if (flag)
            {
                int num;
                int num2;
                int num7;
                int num8;
                if (!GetFirstAndLastSelected(allInstanceIDs, selectedInstanceIDs, out num, out num2))
                {
                    list.Add(clickedInstanceID);
                    return list;
                }
                int num3 = -1;
                int num4 = -1;
                for (int i = 0; i < allInstanceIDs.Count; i++)
                {
                    if (allInstanceIDs[i] == clickedInstanceID)
                    {
                        num3 = i;
                    }
                    if ((lastClickedInstanceID != 0) && (allInstanceIDs[i] == lastClickedInstanceID))
                    {
                        num4 = i;
                    }
                }
                Assert.That(num3 != -1);
                int num6 = 0;
                if (num4 != -1)
                {
                    num6 = (num3 <= num4) ? -1 : 1;
                }
                if (num3 > num2)
                {
                    num7 = num;
                    num8 = num3;
                }
                else if ((num3 >= num) && (num3 < num2))
                {
                    if (num6 > 0)
                    {
                        num7 = num3;
                        num8 = num2;
                    }
                    else
                    {
                        num7 = num;
                        num8 = num3;
                    }
                }
                else
                {
                    num7 = num3;
                    num8 = num2;
                }
                for (int j = num7; j <= num8; j++)
                {
                    list.Add(allInstanceIDs[j]);
                }
                return list;
            }
            if (keepMultiSelection && selectedInstanceIDs.Contains(clickedInstanceID))
            {
                list.AddRange(selectedInstanceIDs);
                return list;
            }
            list.Add(clickedInstanceID);
            return list;
        }

        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern string GetNoDiffToolsDetectedMessage();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern UnityEngine.Object GetObjectFromInstanceID(int instanceID);
        public static Camera[] GetSceneViewCameras()
        {
            return SceneView.GetAllSceneCameras();
        }

        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern string GetUnityBuildBranchUrl();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern string GetUnityCopyright();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern int GetUnityRevision();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern int GetUnityVersionDate();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern bool HasAdvancedLicenseOnBuildTarget(BuildTarget target);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern bool HasFullscreenCamera();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern bool HasMaint();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern bool HasPro();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern DragAndDropVisualMode HierarchyWindowDrag(HierarchyProperty property, bool perform);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        internal static extern DragAndDropVisualMode InspectorWindowDrag(UnityEngine.Object[] targets, bool perform);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern Material[] InstantiateMaterialsInEditMode(UnityEngine.Renderer renderer);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern Rect INTERNAL_CALL_GetBoundsOfDesktopAtPoint(ref Vector2 pos);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern Color[] INTERNAL_CALL_ReadScreenPixel(ref Vector2 pixelPos, int sizex, int sizey);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern DragAndDropVisualMode INTERNAL_CALL_SceneViewDrag(UnityEngine.Object dropUpon, ref Vector3 worldPosition, ref Vector2 viewportPosition, bool perform);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern void INTERNAL_CALL_SetCustomLighting(Light[] lights, ref Color ambient);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        private static extern Bounds INTERNAL_CALL_TransformBounds(ref Bounds b, Transform t);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern bool IsUnityBeta();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern UnityEngine.Object[] LoadSerializedFileAndForget(string path);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void OnGameViewFocus(bool focus);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void OpenEditorConsole();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern bool OpenFileAtLineExternal(string filename, int line);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void OpenPlayerConsole();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern bool ProjectCanBeAppended(string location);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern DragAndDropVisualMode ProjectWindowDrag(HierarchyProperty property, bool perform);
        public static Color[] ReadScreenPixel(Vector2 pixelPos, int sizex, int sizey)
        {
            return INTERNAL_CALL_ReadScreenPixel(ref pixelPos, sizex, sizey);
        }

        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void ReloadWindowLayoutMenu();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void RemoveCustomLighting();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void RepaintAllViews();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void RequestScriptReload();
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void ResetCursor();
        public static void SaveEditorSettingsList(string prefix, string[] aList, int count)
        {
            int num;
            for (num = 0; num < aList.Length; num++)
            {
                EditorPrefs.SetString(prefix + (num + 1), aList[num]);
            }
            for (num = aList.Length + 1; num <= count; num++)
            {
                EditorPrefs.DeleteKey(prefix + num);
            }
        }

        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void SaveToSerializedFileAndForget(UnityEngine.Object[] obj, string path, bool allowTextSerialization);
        public static DragAndDropVisualMode SceneViewDrag(UnityEngine.Object dropUpon, Vector3 worldPosition, Vector2 viewportPosition, bool perform)
        {
            return INTERNAL_CALL_SceneViewDrag(dropUpon, ref worldPosition, ref viewportPosition, perform);
        }

        public static void SetCustomLighting(Light[] lights, Color ambient)
        {
            INTERNAL_CALL_SetCustomLighting(lights, ref ambient);
        }

        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void SetIsInspectorExpanded(UnityEngine.Object obj, bool isExpanded);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void SetupCustomDll(string dllName, string dllLocation);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void SetupShaderMenu(Material material);
        public static void ShowGameView()
        {
            WindowLayout.ShowAppropriateViewOnEnterExitPlaymode(true);
        }

        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern void SwitchSkinAndRepaintAllViews();
        public static string TextifyEvent(Event evt)
        {
            if (evt == null)
            {
                return "none";
            }
            string str = null;
            KeyCode keyCode = evt.keyCode;
            switch (keyCode)
            {
                case KeyCode.Keypad0:
                    str = "[0]";
                    break;

                case KeyCode.Keypad1:
                    str = "[1]";
                    break;

                case KeyCode.Keypad2:
                    str = "[2]";
                    break;

                case KeyCode.Keypad3:
                    str = "[3]";
                    break;

                case KeyCode.Keypad4:
                    str = "[4]";
                    break;

                case KeyCode.Keypad5:
                    str = "[5]";
                    break;

                case KeyCode.Keypad6:
                    str = "[6]";
                    break;

                case KeyCode.Keypad7:
                    str = "[7]";
                    break;

                case KeyCode.Keypad8:
                    str = "[8]";
                    break;

                case KeyCode.Keypad9:
                    str = "[9]";
                    break;

                case KeyCode.KeypadPeriod:
                    str = "[.]";
                    break;

                case KeyCode.KeypadDivide:
                    str = "[/]";
                    break;

                case KeyCode.KeypadMinus:
                    str = "[-]";
                    break;

                case KeyCode.KeypadPlus:
                    str = "[+]";
                    break;

                case KeyCode.KeypadEnter:
                    str = "enter";
                    break;

                case KeyCode.KeypadEquals:
                    str = "[=]";
                    break;

                case KeyCode.UpArrow:
                    str = "up";
                    break;

                case KeyCode.DownArrow:
                    str = "down";
                    break;

                case KeyCode.RightArrow:
                    str = "right";
                    break;

                case KeyCode.LeftArrow:
                    str = "left";
                    break;

                case KeyCode.Insert:
                    str = "insert";
                    break;

                case KeyCode.Home:
                    str = "home";
                    break;

                case KeyCode.End:
                    str = "end";
                    break;

                case KeyCode.PageUp:
                    str = "page up";
                    break;

                case KeyCode.PageDown:
                    str = "page down";
                    break;

                case KeyCode.F1:
                    str = "F1";
                    break;

                case KeyCode.F2:
                    str = "F2";
                    break;

                case KeyCode.F3:
                    str = "F3";
                    break;

                case KeyCode.F4:
                    str = "F4";
                    break;

                case KeyCode.F5:
                    str = "F5";
                    break;

                case KeyCode.F6:
                    str = "F6";
                    break;

                case KeyCode.F7:
                    str = "F7";
                    break;

                case KeyCode.F8:
                    str = "F8";
                    break;

                case KeyCode.F9:
                    str = "F9";
                    break;

                case KeyCode.F10:
                    str = "F10";
                    break;

                case KeyCode.F11:
                    str = "F11";
                    break;

                case KeyCode.F12:
                    str = "F12";
                    break;

                case KeyCode.F13:
                    str = "F13";
                    break;

                case KeyCode.F14:
                    str = "F14";
                    break;

                case KeyCode.F15:
                    str = "F15";
                    break;

                default:
                    if (keyCode == KeyCode.Backspace)
                    {
                        str = "backspace";
                    }
                    else if (keyCode == KeyCode.Return)
                    {
                        str = "return";
                    }
                    else if (keyCode == KeyCode.Escape)
                    {
                        str = "[esc]";
                    }
                    else if (keyCode == KeyCode.Delete)
                    {
                        str = "delete";
                    }
                    else
                    {
                        str = string.Empty + evt.keyCode;
                    }
                    break;
            }
            string str2 = string.Empty;
            if (evt.alt)
            {
                str2 = str2 + "Alt+";
            }
            if (evt.command)
            {
                str2 = str2 + ((Application.platform != RuntimePlatform.OSXEditor) ? "Ctrl+" : "Cmd+");
            }
            if (evt.control)
            {
                str2 = str2 + "Ctrl+";
            }
            if (evt.shift)
            {
                str2 = str2 + "Shift+";
            }
            return (str2 + str);
        }

        public static Bounds TransformBounds(Bounds b, Transform t)
        {
            return INTERNAL_CALL_TransformBounds(ref b, t);
        }

        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern bool Xbox360GenerateSPAConfig(string spaPath);
        [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
        public static extern bool Xbox360SaveSplashScreenToFile(Texture2D image, string spaPath);

        public static float defaultScreenHeight { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }

        public static float defaultScreenWidth { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }

        public static float defaultWebScreenHeight { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }

        public static float defaultWebScreenWidth { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }

        public static int[] expandedProjectWindowItems { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }

        public static bool ignoreInspectorChanges { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }

        public static bool inBatchMode { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }

        public static bool isHumanControllingUs { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }

        public static string[] layers { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }

        public static string[] tags { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }

        public static string unityPreferencesFolder { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    }
}

